home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / RxSrc / msgbase_areas.c < prev    next >
C/C++ Source or Header  |  1995-06-25  |  10KB  |  362 lines
  1. #include <exec/types.h>
  2. #include <exec/exec.h>
  3. #include <libraries/wwbbs.h>
  4. #include <ctype.h>
  5. #include <math.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9.  
  10. #include <proto/dos.h>
  11. #include <proto/exec.h>
  12. #include <proto/rexxsyslib.h>
  13. #include <proto/wwbbs.h>
  14.  
  15. #include "rx.h"
  16.  
  17. #include "msgbase.h"
  18.  
  19. void JoinMessageArea(BYTE *id)
  20.     {
  21.         if(message_global)
  22.             {
  23.                 if(strlen(message_area))
  24.                     {
  25.                         if(strlen(message_group))
  26.                             {
  27.                                 if(FindName(message_global,message_group))
  28.                                     {
  29.                                         if(DeleteMessageGlobal(message_global,message_group))
  30.                                             printf("~s\nMessage area `%s' removed from global list.\n",message_fullpath);
  31.                                         else
  32.                                             printf("~s\nUnable to remove message area `%s' from global list.\n",message_fullpath);
  33.                                     }
  34.                                 else
  35.                                     {
  36.                                         if(AddMessageGlobal(message_global,message_group,0))
  37.                                             printf("~s\nMessage area `%s' added to global list.\n",message_fullpath);
  38.                                         else
  39.                                             printf("~s\nUnable to add message area `%s' from global list.\n",message_fullpath);
  40.                                     }
  41.                             }
  42.                     }
  43.                 else
  44.                     printf("~s\nPlease enter a message area first.\n");
  45.             }
  46.     }
  47.  
  48. void ChangeMessageArea(BYTE *id)
  49.     {
  50.         if(message_global)
  51.             {
  52.                 BYTE user[33];
  53.                 strcpy(user,"");
  54.                 GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  55.                 if(strlen(user))
  56.                     {
  57.                         UBYTE accesslevel=0;
  58.                         if(GetUserTags(USRTAG_Name,user,USRTAG_AccessLevel,&accesslevel,TAG_END))
  59.                             {
  60.                                 BYTE area[33];
  61.                                 strcpy(area,"");
  62.                                 if(SelectMessageArea(id,accesslevel,area))
  63.                                     {
  64.                                         BYTE group[21];
  65.                                         BOOL child=FALSE;
  66.                                         strcpy(group,"");
  67.                                         if(GetConfigTags(CFGTAG_Path,message_path,CFGTAG_Name,area,CFGTAG_Child,&child,MBTAG_Group,group,TAG_END))
  68.                                             {
  69.                                                 if(child)
  70.                                                     {
  71.                                                         AddPart(message_path,area,255);
  72.                                                         strcpy(message_area,"");
  73.                                                         strcpy(message_group,"");
  74.                                                         message_current=0;
  75.                                                         strcpy(message_read,"");
  76.                                                         message_currentthread=0;
  77.                                                         {
  78.                                                             char *p;
  79.                                                             if(p=strchr(message_path,'/'))
  80.                                                                 {
  81.                                                                     p++;
  82.                                                                     sprintf(message_fullpath,"%s/None",p);
  83.                                                                 }
  84.                                                             else
  85.                                                                 strcpy(message_fullpath,"None");
  86.                                                             printf("~s\nCurrent directory is `%s'.\n",(p) ? p : "None");
  87.                                                         }
  88.                                                     }
  89.                                                 else
  90.                                                     {
  91.                                                         strcpy(message_area,area);
  92.                                                         strcpy(message_group,group);
  93.                                                         message_current=0;
  94.                                                         if(FindName(message_global,group))
  95.                                                             strcpy(message_read,GetMessageGlobalRead(message_global,group));
  96.                                                         else
  97.                                                             strcpy(message_read,"");
  98.                                                         message_currentthread=0;
  99.                                                         {
  100.                                                             char *p;
  101.                                                             if(p=strchr(message_path,'/'))
  102.                                                                 {
  103.                                                                     p++;
  104.                                                                     sprintf(message_fullpath,"%s/%s",p,message_area);
  105.                                                                 }
  106.                                                             else
  107.                                                                 strcpy(message_fullpath,message_area);
  108.                                                         }
  109.                                                         printf("\n");
  110.                                                         {
  111.                                                             APTR _group;
  112.                                                             if(_group=OpenMessageGroup(message_path,message_area,SHARED_LOCK))
  113.                                                                 {
  114.                                                                     DisplayMessageArea(id,_group);
  115.                                                                     CloseMessageGroup(_group);
  116.                                                                 }
  117.                                                         }
  118.                                                     }
  119.                                             }
  120.                                     }
  121.                             }
  122.                     }
  123.             }
  124.     }
  125.  
  126. void ParentMessageArea(BYTE *id)
  127.     {
  128.         BOOL newarea=FALSE;
  129.         if(strlen(message_area))
  130.             {
  131.                 strcpy(message_area,"");
  132.                 newarea=TRUE;
  133.             }
  134.         else
  135.             {
  136.                 if(strchr(message_path,'/'))
  137.                     {
  138.                         {
  139.                             char *p;
  140.                             p=PathPart(message_path);
  141.                             *p=NULL;
  142.                         }
  143.                         newarea=TRUE;
  144.                     }
  145.             }
  146.         if(newarea)
  147.             {
  148.                 message_current=0;
  149.                 strcpy(message_read,"");
  150.                 message_currentthread=0;
  151.                 {
  152.                     char *p;
  153.                     if(p=strchr(message_path,'/'))
  154.                         {
  155.                             p++;
  156.                             sprintf(message_fullpath,"%s/None",p);
  157.                         }
  158.                     else
  159.                         strcpy(message_fullpath,"None");
  160.                     printf("~s\nCurrent directory is `%s'.\n",(p) ? p : "None");
  161.                 }
  162.             }
  163.         else
  164.             printf("~s\nParent area does not exist.\n");
  165.     }
  166.  
  167. void NextMessageArea(BYTE *id)
  168.     {
  169.         if(message_global)
  170.             {
  171.                 BYTE user[33];
  172.                 GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  173.                 if(strlen(user))
  174.                     {
  175.                         UBYTE accesslevel=0;
  176.                         if(GetUserTags(USRTAG_Name,user,USRTAG_AccessLevel,&accesslevel,TAG_END))
  177.                             {
  178.                                 BOOL kg=TRUE;
  179.                                 BYTE temp_path[256],temp_area[33];
  180.                                 BYTE accessrange[21];
  181.                                 BYTE group[21];
  182.                                 strcpy(temp_path,message_path);
  183.                                 strcpy(temp_area,message_area);
  184.                                 strcpy(accessrange,"");
  185.                                 strcpy(group,"");
  186.                                 while(kg && GetNextArea(temp_path,temp_area))
  187.                                     {
  188.                                         if(GetConfigTags(CFGTAG_Path,temp_path,CFGTAG_Name,temp_area,MBTAG_AccessRange,accessrange,MBTAG_Group,group,TAG_END))
  189.                                             {
  190.                                                 if(IsRange(accessrange,accesslevel))
  191.                                                     {
  192.                                                         if(FindName(message_global,group))
  193.                                                             {
  194.                                                                 strcpy(message_path,temp_path);
  195.                                                                 strcpy(message_area,temp_area);
  196.                                                                 strcpy(message_group,group);
  197.                                                                 message_current=0;
  198.                                                                 strcpy(message_read,GetMessageGlobalRead(message_global,group));
  199.                                                                 message_currentthread=0;
  200.                                                                 {
  201.                                                                     char *p;
  202.                                                                     if(p=strchr(message_path,'/'))
  203.                                                                         {
  204.                                                                             p++;
  205.                                                                             sprintf(message_fullpath,"%s/%s",p,message_area);
  206.                                                                         }
  207.                                                                     else
  208.                                                                         strcpy(message_fullpath,message_area);
  209.                                                                 }
  210.                                                                 printf("\n");
  211.                                                                 {
  212.                                                                     APTR _group;
  213.                                                                     if(_group=OpenMessageGroup(message_path,message_area,SHARED_LOCK))
  214.                                                                         {
  215.                                                                             DisplayMessageArea(id,_group);
  216.                                                                             CloseMessageGroup(_group);
  217.                                                                         }
  218.                                                                 }
  219.                                                                 kg=FALSE;
  220.                                                             }
  221.                                                     }
  222.                                             }
  223.                                     }
  224.                                 if(kg)
  225.                                     printf("~s\nNext area does not exist.\n");
  226.                             }
  227.                     }
  228.             }
  229.     }
  230.  
  231. void PreviousMessageArea(BYTE *id)
  232.     {
  233.         if(message_global)
  234.             {
  235.                 BYTE user[33];
  236.                 GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  237.                 if(strlen(user))
  238.                     {
  239.                         UBYTE accesslevel=0;
  240.                         if(GetUserTags(USRTAG_Name,user,USRTAG_AccessLevel,&accesslevel,TAG_END))
  241.                             {
  242.                                 BOOL kg=TRUE;
  243.                                 BYTE temp_path[256],temp_area[33];
  244.                                 BYTE accessrange[21];
  245.                                 BYTE group[21];
  246.                                 strcpy(temp_path,message_path);
  247.                                 strcpy(temp_area,message_area);
  248.                                 strcpy(accessrange,"");
  249.                                 strcpy(group,"");
  250.                                 while(kg && GetPreviousArea(temp_path,temp_area))
  251.                                     {
  252.                                         if(GetConfigTags(CFGTAG_Path,temp_path,CFGTAG_Name,temp_area,MBTAG_AccessRange,accessrange,MBTAG_Group,group,TAG_END))
  253.                                             {
  254.                                                 if(IsRange(accessrange,accesslevel))
  255.                                                     {
  256.                                                         if(FindName(message_global,group))
  257.                                                             {
  258.                                                                 strcpy(message_path,temp_path);
  259.                                                                 strcpy(message_area,temp_area);
  260.                                                                 strcpy(message_group,group);
  261.                                                                 message_current=0;
  262.                                                                 strcpy(message_read,GetMessageGlobalRead(message_global,group));
  263.                                                                 message_currentthread=0;
  264.                                                                 {
  265.                                                                     char *p;
  266.                                                                     if(p=strchr(message_path,'/'))
  267.                                                                         {
  268.                                                                             p++;
  269.                                                                             sprintf(message_fullpath,"%s/%s",p,message_area);
  270.                                                                         }
  271.                                                                     else
  272.                                                                         strcpy(message_fullpath,message_area);
  273.                                                                 }
  274.                                                                 printf("\n");
  275.                                                                 {
  276.                                                                     APTR _group;
  277.                                                                     if(_group=OpenMessageGroup(message_path,message_area,SHARED_LOCK))
  278.                                                                         {
  279.                                                                             DisplayMessageArea(id,_group);
  280.                                                                             CloseMessageGroup(_group);
  281.                                                                         }
  282.                                                                 }
  283.                                                                 kg=FALSE;
  284.                                                             }
  285.                                                     }
  286.                                             }
  287.                                     }
  288.                                 if(kg)
  289.                                     printf("~s\nPrevious area does not exist.\n");
  290.                             }
  291.                     }
  292.             }
  293.     }
  294.  
  295. void DisplayMessageArea(BYTE *id,APTR group)
  296.     {
  297.         BYTE user[33];
  298.         strcpy(user,"");
  299.         GetStatusTags(STTAG_Name,id,STTAG_UserName,user,TAG_END);
  300.         if(strlen(user))
  301.             {
  302.                 ULONG nummsgs=0,newmsgs=0;
  303.                 {
  304.                     ULONG next=0;
  305.                     while(next=GetNextMessage(group,next))
  306.                         {
  307.                             if(GetMessageTags(group,MSGTAG_ID,next,TAG_END))
  308.                                 {
  309.                                     nummsgs++;
  310.                                     if(!IsRange(message_read,next))
  311.                                         newmsgs++;
  312.                                 }
  313.                         }
  314.                 }
  315.                 printf("~hMessage Area: %s\n\n",message_fullpath);
  316.                 {
  317.                     BYTE filename[256];
  318.                     sprintf(filename,"WWBBS:Messages/%s.desc",message_group);
  319.                     {
  320.                         BPTR fh;
  321.                         if(fh=Open(filename,MODE_OLDFILE))
  322.                             {
  323.                                 Close(fh);
  324.                                 ShowText(filename);
  325.                                 printf("\n");
  326.                             }
  327.                     }
  328.                 }
  329.                 printf("~o");
  330.                 printf("Messages Numbered: %ld-%ld\n",GetNextMessage(group,0),GetPreviousMessage(group,~0));
  331.                 printf("New Messages:      %ld\n",newmsgs);
  332.                 printf("Total Messages:    %ld\n",nummsgs);
  333.                 SetMessageDoorVariables(id);
  334.             }
  335.     }
  336.  
  337. void SetMessageDoorVariables(BYTE *id)
  338.     {
  339.         BYTE buff[11];
  340.         BYTE accessrange[21],quoteheader[81];
  341.         ULONG days=0;
  342.         BOOL readonly=FALSE,autojoin=FALSE;
  343.         strcpy(accessrange,"");
  344.         strcpy(quoteheader,"");
  345.         GetConfigTags(CFGTAG_Path,message_path,CFGTAG_Name,message_area,
  346.                                         MBTAG_AccessRange,accessrange,
  347.                                         MBTAG_QuoteHeader,quoteheader,
  348.                                         MBTAG_Days,&days,
  349.                                         MBTAG_ReadOnly,&readonly,
  350.                                         MBTAG_AutoJoin,&autojoin,
  351.                                         TAG_END);
  352.         SetVar("MESSAGEBASE_PATH",message_path,-1,GVF_LOCAL_ONLY);
  353.         SetVar("MESSAGEBASE_AREA",message_area,-1,GVF_LOCAL_ONLY);
  354.         SetVar("MESSAGEBASE_ACCESSRANGE",accessrange,-1,GVF_LOCAL_ONLY);
  355.         SetVar("MESSAGEBASE_GROUP",message_group,-1,GVF_LOCAL_ONLY);
  356.         SetVar("MESSAGEBASE_QUOTEHEADER",quoteheader,-1,GVF_LOCAL_ONLY);
  357.         sprintf(buff,"%ld",days);
  358.         SetVar("MESSAGEBASE_DAYS",buff,-1,GVF_LOCAL_ONLY);
  359.         SetVar("MESSAGEBASE_READONLY",(readonly) ? "1" : "0",-1,GVF_LOCAL_ONLY);
  360.         SetVar("MESSAGEBASE_AUTOJOIN",(autojoin) ? "1" : "0",-1,GVF_LOCAL_ONLY);
  361.     }
  362.